﻿using UIOC.Attributes;

namespace UIOC.Observable {

    public interface IObservableBoolData : IObservableData<bool> { }
    public interface IBoolData : IData<bool>, IObservableBoolData { }

    public interface IObservableBool : IObservableStructBox<bool>, IObservableBoolData { }
    public interface IBool : IStructBox<bool>, IObservableBool, IBoolData { }

    public interface IObservableByteData : IObservableData<byte> { }
    public interface IByteData : IData<byte>, IObservableByteData { }

    public interface IObservableByte : IObservableStructBox<byte>, IObservableByteData { }
    public interface IByte : IStructBox<byte>, IObservableByte, IByteData { }

    public interface IObservableSByteData : IObservableData<sbyte> { }
    public interface ISByteData : IData<sbyte>, IObservableSByteData { }

    public interface IObservableSByte : IObservableStructBox<sbyte>, IObservableSByteData { }
    public interface ISByte : IStructBox<sbyte>, IObservableSByte, ISByteData { }

    public interface IObservableShortData : IObservableData<short> { }
    public interface IShortData : IData<short>, IObservableShortData { }

    public interface IObservableShort : IObservableStructBox<short>, IObservableShortData { }
    public interface IShort : IStructBox<short>, IObservableShort, IShortData { }

    public interface IObservableUShortData : IObservableData<ushort> { }
    public interface IUShortData : IData<ushort>, IObservableUShortData { }

    public interface IObservableUShort : IObservableStructBox<ushort>, IObservableUShortData { }
    public interface IUShort : IStructBox<ushort>, IObservableUShort, IUShortData { }

    public interface IObservableIntData : IObservableData<int> { }
    public interface IIntData : IData<int>, IObservableIntData { }

    public interface IObservableInt : IObservableStructBox<int>, IObservableIntData { }
    public interface IInt : IStructBox<int>, IObservableInt, IIntData { }

    public interface IObservableUIntData : IObservableData<uint> { }
    public interface IUIntData : IData<uint>, IObservableUIntData { }

    public interface IObservableUInt : IObservableStructBox<uint>, IObservableUIntData { }
    public interface IUInt : IStructBox<uint>, IObservableUInt, IUIntData { }

    public interface IObservableLongData : IObservableData<long> { }
    public interface ILongData : IData<long>, IObservableLongData { }

    public interface IObservableLong : IObservableStructBox<long>, IObservableLongData { }
    public interface ILong : IStructBox<long>, IObservableLong, ILongData { }

    public interface IObservableULongData : IObservableData<ulong> { }
    public interface IULongData : IData<ulong>, IObservableULongData { }

    public interface IObservableULong : IObservableStructBox<ulong>, IObservableULongData { }
    public interface IULong : IStructBox<ulong>, IObservableULong, IULongData { }

    public interface IObservableFloatData : IObservableData<float> { }
    public interface IFloatData : IData<float>, IObservableFloatData { }

    public interface IObservableFloat : IObservableStructBox<float>, IObservableFloatData { }
    public interface IFloat : IStructBox<float>, IObservableFloat, IFloatData { }

    public interface IObservableDoubleData : IObservableData<double> { }
    public interface IDoubleData : IData<double>, IObservableDoubleData { }

    public interface IObservableDouble : IObservableStructBox<double>, IObservableDoubleData { }
    public interface IDouble : IStructBox<double>, IObservableDouble, IDoubleData { }

    public interface IObservableDateTimeData : IObservableData<System.DateTime> { }
    public interface IDateTimeData : IData<System.DateTime>, IObservableDateTimeData { }

    public interface IObservableDateTime : IObservableStructBox<System.DateTime>, IObservableDateTimeData { }
    public interface IDateTime : IStructBox<System.DateTime>, IObservableDateTime, IDateTimeData { }

    public interface IObservableTimeSpanData : IObservableData<System.TimeSpan> { }
    public interface ITimeSpanData : IData<System.TimeSpan>, IObservableTimeSpanData { }

    public interface IObservableTimeSpan : IObservableStructBox<System.TimeSpan>, IObservableTimeSpanData { }
    public interface ITimeSpan : IStructBox<System.TimeSpan>, IObservableTimeSpan, ITimeSpanData { }

    [Implement(typeof(IObservableBool))]
    [Implement(typeof(IObservableBoolData))]
    [Implement(typeof(IBool))]
    [Implement(typeof(IBoolData))]
    [Implement(typeof(IObservableStructBox<bool>))]
    [Implement(typeof(IObservableData<bool>))]
    [Implement(typeof(IStructBox<bool>))]
    [Implement(typeof(IData<bool>))]
    public partial class Bool : StructBox<bool>, IBool { }

    [Implement(typeof(IObservableByte))]
    [Implement(typeof(IObservableByteData))]
    [Implement(typeof(IByte))]
    [Implement(typeof(IByteData))]
    [Implement(typeof(IObservableStructBox<byte>))]
    [Implement(typeof(IObservableData<byte>))]
    [Implement(typeof(IStructBox<byte>))]
    [Implement(typeof(IData<byte>))]
    public partial class Byte : StructBox<byte>, IByte { }

    [Implement(typeof(IObservableSByte))]
    [Implement(typeof(IObservableSByteData))]
    [Implement(typeof(ISByte))]
    [Implement(typeof(ISByteData))]
    [Implement(typeof(IObservableStructBox<sbyte>))]
    [Implement(typeof(IObservableData<sbyte>))]
    [Implement(typeof(IStructBox<sbyte>))]
    [Implement(typeof(IData<sbyte>))]
    public partial class SByte : StructBox<sbyte>, ISByte { }

    [Implement(typeof(IObservableShort))]
    [Implement(typeof(IObservableShortData))]
    [Implement(typeof(IShort))]
    [Implement(typeof(IShortData))]
    [Implement(typeof(IObservableStructBox<short>))]
    [Implement(typeof(IObservableData<short>))]
    [Implement(typeof(IStructBox<short>))]
    [Implement(typeof(IData<short>))]
    public partial class Short : StructBox<short>, IShort { }

    [Implement(typeof(IObservableUShort))]
    [Implement(typeof(IObservableUShortData))]
    [Implement(typeof(IUShort))]
    [Implement(typeof(IUShortData))]
    [Implement(typeof(IObservableStructBox<ushort>))]
    [Implement(typeof(IObservableData<ushort>))]
    [Implement(typeof(IStructBox<ushort>))]
    [Implement(typeof(IData<ushort>))]
    public partial class UShort : StructBox<ushort>, IUShort { }

    [Implement(typeof(IObservableInt))]
    [Implement(typeof(IObservableIntData))]
    [Implement(typeof(IInt))]
    [Implement(typeof(IIntData))]
    [Implement(typeof(IObservableStructBox<int>))]
    [Implement(typeof(IObservableData<int>))]
    [Implement(typeof(IStructBox<int>))]
    [Implement(typeof(IData<int>))]
    public partial class Int : StructBox<int>, IInt { }

    [Implement(typeof(IObservableUInt))]
    [Implement(typeof(IObservableUIntData))]
    [Implement(typeof(IUInt))]
    [Implement(typeof(IUIntData))]
    [Implement(typeof(IObservableStructBox<uint>))]
    [Implement(typeof(IObservableData<uint>))]
    [Implement(typeof(IStructBox<uint>))]
    [Implement(typeof(IData<uint>))]
    public partial class UInt : StructBox<uint>, IUInt { }

    [Implement(typeof(IObservableLong))]
    [Implement(typeof(IObservableLongData))]
    [Implement(typeof(ILong))]
    [Implement(typeof(ILongData))]
    [Implement(typeof(IObservableStructBox<long>))]
    [Implement(typeof(IObservableData<long>))]
    [Implement(typeof(IStructBox<long>))]
    [Implement(typeof(IData<long>))]
    public partial class Long : StructBox<long>, ILong { }

    [Implement(typeof(IObservableULong))]
    [Implement(typeof(IObservableULongData))]
    [Implement(typeof(IULong))]
    [Implement(typeof(IULongData))]
    [Implement(typeof(IObservableStructBox<ulong>))]
    [Implement(typeof(IObservableData<ulong>))]
    [Implement(typeof(IStructBox<ulong>))]
    [Implement(typeof(IData<ulong>))]
    public partial class ULong : StructBox<ulong>, IULong { }

    [Implement(typeof(IObservableFloat))]
    [Implement(typeof(IObservableFloatData))]
    [Implement(typeof(IFloat))]
    [Implement(typeof(IFloatData))]
    [Implement(typeof(IObservableStructBox<float>))]
    [Implement(typeof(IObservableData<float>))]
    [Implement(typeof(IStructBox<float>))]
    [Implement(typeof(IData<float>))]
    public partial class Float : StructBox<float>, IFloat { }

    [Implement(typeof(IObservableDouble))]
    [Implement(typeof(IObservableDoubleData))]
    [Implement(typeof(IDouble))]
    [Implement(typeof(IDoubleData))]
    [Implement(typeof(IObservableStructBox<double>))]
    [Implement(typeof(IObservableData<double>))]
    [Implement(typeof(IStructBox<double>))]
    [Implement(typeof(IData<double>))]
    public partial class Double : StructBox<double>, IDouble { }

    [Implement(typeof(IObservableDateTime))]
    [Implement(typeof(IObservableDateTimeData))]
    [Implement(typeof(IDateTime))]
    [Implement(typeof(IDateTimeData))]
    [Implement(typeof(IObservableStructBox<System.DateTime>))]
    [Implement(typeof(IObservableData<System.DateTime>))]
    [Implement(typeof(IStructBox<System.DateTime>))]
    [Implement(typeof(IData<System.DateTime>))]
    public partial class DateTime : StructBox<System.DateTime>, IDateTime { }

    [Implement(typeof(IObservableTimeSpan))]
    [Implement(typeof(IObservableTimeSpanData))]
    [Implement(typeof(ITimeSpan))]
    [Implement(typeof(ITimeSpanData))]
    [Implement(typeof(IObservableStructBox<System.TimeSpan>))]
    [Implement(typeof(IObservableData<System.TimeSpan>))]
    [Implement(typeof(IStructBox<System.TimeSpan>))]
    [Implement(typeof(IData<System.TimeSpan>))]
    public partial class TimeSpan : StructBox<System.TimeSpan>, ITimeSpan { }
}